# -*- coding: utf-8 -*-

#    Copyright (C) 2014 by Promotux
#                       di Francesco Meloni snc - http://www.promotux.it/

#    Author: Francesco Meloni  <francesco@promotux.it>

#    This file is part of OdCollect.

#    OdCollect is free software: you can redistribute it and/or modify
#    it under the terms of the GNU General Public License as published by
#    the Free Software Foundation, either version 2 of the License, or
#    (at your option) any later version.

#    OdCollect is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU General Public License for more details.

#    You should have received a copy of the GNU General Public License
#    along with OdCollect.  If not, see <http://www.gnu.org/licenses/>.

import base64
import datetime
import hashlib
from web_lib.page import Page
from web_lib.webutils import Response, expose, json, salvaInSessione, leggiInSessione, permalinkaTitle , change_schema
import Environment
from web_lib.session import Session as S
from lib.utils import *
from webEnv import *
from PIL import Image, ImageFile
from dao.Ente import Ente

def convert_jpg(img_dir="/home/vete/", scale_img=100, img_quality=70):

    img_files = [f for f in os.listdir(img_dir) if f.endswith('JPG')]
    for i in range(len(img_files)):
        img_file = Image.open(img_dir+"/"+img_files[i])
        if scale_img == 100:
            width, height = img_file.size
        else:
            width, height = (int(scale_img * img_file.size[0] / 100.0),
                            int(scale_img * img_file.size[1] / 100.0))

        img_file = img_file.resize((width, height), Image.ANTIALIAS)
        try:
            img_file.save(img_dir+"/"+img_files[i],
                          optimize=True,
                          quality=img_quality,
                          progressive=True)
        except IOError:
            ImageFile.MAXBLOCK = width * height
            img_file.save(img_dir+"/"+img_files[i],
                          optimize=True,
                          quality=img_quality,
                          progressive=True)



def genericUpdate(level=None):
    f = req.files['imageArticle']
    name =f.filename
    data = f.read()
    subdomainUrl = Environment.templates_dir + Environment.subdomain
    fileObj = open(subdomainUrl + "/filesUpdated/" + name ,"wb")
    fileObj.write(data)
    fileObj.close()

@expose('/pg/ac_Segnalazione/<action>')
@expose('/pg/ac_Segnalazione/')
#@expose('/pg/ac_Faq')
def anagraficaSegnalazione(req, action=None):
    """
    """
    def __show__(req, action=None):
        from dao.Segnalazione import Segnalazione
        pageData = {'file': "/pg/ac_Segnalazione"}
        return Page(req).render(pageData)

    def __list__(req, action=None):
        codice = req.args.get("codice")
        sorting = req.args.get("jtSorting")
        offset = req.args.get("jtStartIndex")
        batchSize = req.args.get("jtPageSize")
        if codice and codice != "None" and codice != "":
            ente = Ente().select(codice=codice)
            if ente:
                Environment.census = True
                Environment.sch = ente[0].denominazione_breve.lower().replace(" ", "")
                change_schema(req, ente[0].denominazione_breve.lower().replace(" ", ""))
                fk_ente = ente[0].id
                fk_username = req.args.get("fk_username")
                fk_email = req.args.get("fk_email")
                fk_id_role = req.args.get("fk_id_role")
            else:
                return Response("{}")
        else:
            fk_username = req.form.get("fk_username")
            fk_email = req.form.get("fk_email")
            fk_id_role = req.form.get("fk_id_role")

        from dao.Segnalazione import Segnalazione
        daos = Segnalazione().select(
                            batchSize=batchSize,
                            usern=fk_username,
                            email=fk_email,
                            idRole=fk_id_role,
                            offset=offset,
                            orderBy=sorting)
        count = Segnalazione().count(
                            usern=fk_username,
                            email=fk_email,
                            idRole=fk_id_role,
                            batchSize=None)

        item = {
            "Result":"OK",
            "TotalRecordCount": count,
            "Records": prep2json(daos)
            }
        jasoned = json.dumps(item, ensure_ascii=False, encoding='utf8')
        Environment.census = False
        Environment.sch = None
        return Response(jasoned)

    def __edit__(req, action=None):
        from dao.TipoSegnalazione import TipoSegnalazione
        from dao.PrioritaSegnalazione import PrioritaSegnalazione
        from dao.Segnalazione import Segnalazione
        from dao.StatoSegnalazione import StatoSegnalazione
        id = req.form.get("id")
        if id and id != "None":
            d = Segnalazione().getRecord(id=int(id))
        else:
            d = Segnalazione()
        pageData = {'file': "pg/addedit/ae_segnalazione",
                    "dao": d,
                    "tiposegnalazione": TipoSegnalazione().select(batchSize=None),
                    "prioritasegnalazione": PrioritaSegnalazione().select(batchSize=None),
                    "statosegnalazione": StatoSegnalazione().select(batchSize=None),
                    }
        return Page(req).render(pageData)



    def __create__update__(req, action=None):
        """Aggiunge una riga alle pesate"""
        import imghdr
        print "REEEEEEEEEEEEEEE", req.form.to_dict()
        codice = req.form.get("codice")
        if codice and codice != "None" and codice != "":
            ente = Ente().select(codice=codice)
            if ente:
                ente = ente[0]
                Environment.census = True
                Environment.sch = ente.denominazione_breve.lower().replace(" ", "")
                change_schema(req, ente.denominazione_breve.lower().replace(" ", ""))
            else:
                return Response("{}")

        from dao.Segnalazione import Segnalazione
        from dao.PercorsoSegnalazione import PercorsoSegnalazione
        from dao.Operatore import Operatore
        operKey =  req.form.get("operKey")
        operId = None
        if operKey and operKey != "" and operKey != "None":
            dd = Operatore().select(passwordKey=operKey)
            if dd and dd[0].active:
                operId = dd[0].id
        idrr = S(req).getUserId()
        id = req.form.get("id")
        print "IDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD", id
        if id and id != "None" and id != "":
            d = Segnalazione().getRecord(id=int(id))
        else:
            d = Segnalazione()
        if not d.numero:
            a= Environment.session.query(func.max(Segnalazione.numero)).all()
            if a:
                try:
                    d.numero = a[0][0] +1
                except:
                    d.numero = 1
        d.denominazione = str(req.form.get("denominazione"))
        d.descrizione = str(req.form.get("descrizione"))
        d.id_operatore = operId
        if "immagine" in req.files:
            f = req.files.get("immagine")
            data = f.read()
            name =f.filename
            if name != "":
                fileObj = open(name ,"wb")
                fileObj.write(data)
                fileObj.close()
                formato = imghdr.what(name)
                #if formato == "jpeg":

                img_file = Image.open(name)
                if img_file.size[0] > 2000:
                    scale_img_low = 2000*100/img_file.size[0]
                else:
                    scale_img_low = 100
                img_quality = 75
                if scale_img_low == 100:
                    width, height = img_file.size
                else:
                    width, height = (int(scale_img_low * img_file.size[0] / 100.0),
                                    int(scale_img_low * img_file.size[1] / 100.0))

                img_file_low = img_file.resize((width, height), Image.ANTIALIAS)

                img_file_low.save(name+"_low."+formato,
                                  optimize=True,
                                  quality=img_quality,
                                  progressive=True)
                with open(name+"_low."+formato, "rb") as imageFile_low:
                    d.immagine_low = base64.b64encode(imageFile_low.read())
                scale_img_thumb = 400*100/img_file.size[0]
                width, height = (int(scale_img_thumb * img_file.size[0] / 100.0),
                                    int(scale_img_thumb * img_file.size[1] / 100.0))
                img_file_thumb = img_file.resize((width, height), Image.ANTIALIAS)
                img_file_thumb.save(name+"_thumb."+formato,
                                  optimize=True,
                                  quality=img_quality,
                                  progressive=True)
                with open(name+"_thumb."+formato, "rb") as imageFile_thumb:
                    d.immagine_thumb = base64.b64encode(imageFile_thumb.read())
                if data:
                    d.immagine = d.immagine_thumb
        else:
            d.immagine = ""
        if not d.immagine and codice:
            d.immagine = req.form.get("image")
            d.immagine_thumb = d.immagine
            d.immagine_low = d.immagine
        try:
            d.id_tipo_segnalazione = int(req.form.get("id_tipo_segnalazione"))
        except:
            d.id_tipo_segnalazione = None
        try:
            d.id_priorita_segnalazione = int(req.form.get("id_priorita_segnalazione"))
        except:
            d.id_priorita_segnalazione = 1
        try:
            d.id_stato_segnalazione = int(req.form.get("id_stato_segnalazione"))
        except:
            d.id_stato_segnalazione = 1
        if not d.data_inserimento:
            d.data_inserimento = datetime.datetime.now()
        d.lat = str(req.form.get("lat"))
        d.lng = str(req.form.get("lng"))
        d.persist()
        if codice:
            jasoned = json.dumps("OK", ensure_ascii=False, encoding='utf8')
            return Response(jasoned)
        else:
            url_red = "/pg/ac_Segnalazione/"
            return Page(req).redirect(url_red)


    def __delete__(req, action=None):
        """Cancella una riga"""
        from dao.Segnalazione import Segnalazione
        id = int(req.form.get("id"))
        d = Segnalazione().getRecord(id=id)
        try:
            d.delete()
            item = {"Result": "OK", }
        except:
            item = {
                "Result":"ERROR",
                "Message": "Cancellazione riga non riuscita"}
        jasoned = json.dumps(item, ensure_ascii=False, encoding='utf8')
        return Response(jasoned)

    def __preview__(req, action=None):

        codice = req.args.get("codice")
        #operKey = req.args.get("operKey")
        if codice and codice != "None" and codice != "":
            from dao.Ente import Ente
            ente = Ente().select(codice=codice)
            if ente:
                Environment.census = True
                Environment.sch = ente[0].denominazione_breve.lower().replace(" ", "")
                change_schema(req, ente[0].denominazione_breve.lower().replace(" ", ""))
        from dao.Segnalazione import Segnalazione
        id = int(req.form.get("id"))
        d = Segnalazione().getRecord(id=id)
        pageData = {'file': "/pg/dettaglio_segnalazione",
                    "dao": d}
        return Page(req).render(pageData)

    def __get_tipi_segnalazione__(req, action=None):
        codice = req.args.get("codice")
        #operKey = req.args.get("operKey")
        if codice and codice != "None" and codice != "":
            from dao.Ente import Ente
            ente = Ente().select(codice=codice)
            if ente:
                Environment.census = True
                Environment.sch = ente[0].denominazione_breve.lower().replace(" ", "")
                change_schema(req, ente[0].denominazione_breve.lower().replace(" ", ""))
                from dao.TipoSegnalazione import TipoSegnalazione
                tai = TipoSegnalazione().select(batchSize=None)
        else:
            tai = []
        jasoned = json.dumps(prep2json(tai), ensure_ascii=False, encoding='utf8')
        return Response(jasoned)

    def __json__(req, action=None):
        """ Gestione della Get per odcensu e del post interno di odcollect
        """
        codice = req.args.get("codice")
        if codice and codice != "None" and codice != "":
            ente = Ente().select(codice=codice)
            if ente:
                ente = ente[0]
                Environment.census = True
                Environment.sch = ente.denominazione_breve.lower().replace(" ", "")
                change_schema(req, ente.denominazione_breve.lower().replace(" ", ""))
            else:
                return Response("{}")

        else:
            return Response("{}")


        from dao.Segnalazione import Segnalazione
        id = req.args.get("id")
        if not id:
            return Response("{}")

        d = Segnalazione().getRecord(id=int(id))
        if not d:
            return Response("{}")
        item = prep2json(d)
        jasoned = json.dumps(item,sort_keys=True, indent=4, separators=(',', ': '), ensure_ascii=False, encoding='utf8')
        Environment.census = False
        Environment.sch = None
        return Response(jasoned)

    if leggiInSessione(req, sezione="Main", chiave="schema") is None:
        url_red = "/pg/main"
    if action=="List":
        return __list__ (req, action=action)
    elif action=="show":
        return __show__(req, action=action)
    elif action=="Create" or action == "Update":
        return __create__update__(req, action=action)
    elif action=="Delete":
        return __delete__(req, action=action)
    elif action=="getTipiSegnalazione":
        return __get_tipi_segnalazione__(req, action=action)
    elif action == "Preview":
        return __preview__(req, action=action)
    elif action == "Daojson":
        return __json__(req, action=action)
    elif action == "Edit":
        return __edit__(req, action=action)
    else:
        return __show__(req, action=action)
